<html>
<head><meta charset="utf-8"><title>Taking advantage of `freeze`? · t-lang/wg-unsafe-code-guidelines · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/index.html">t-lang/wg-unsafe-code-guidelines</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html">Taking advantage of `freeze`?</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="212525886"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212525886" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212525886">(Oct 07 2020 at 08:06)</a>:</h4>
<p>I noticed today that LLVM 10 has <code>freeze</code>: <a href="https://releases.llvm.org/10.0.0/docs/LangRef.html#freeze-instruction">https://releases.llvm.org/10.0.0/docs/LangRef.html#freeze-instruction</a></p>
<p>Given that rustc is on <a href="https://github.com/rust-lang/rust/pull/77063">11-rc3</a>, would it make sense to start adding a freeze intrinsic to explore?  I was thinking about safe ways to expose "fast"-math after &lt;<a href="https://users.rust-lang.org/t/why-i-get-nan-values-when-multiply-by-0/49450/19?u=scottmcm">https://users.rust-lang.org/t/why-i-get-nan-values-when-multiply-by-0/49450/19?u=scottmcm</a>&gt;, in particular.</p>
<p>Is poison a valid-but-unsafe value for rust types like <code>f32</code>?  Or would this need to work on <code>MaybeUninit&lt;f32&gt;</code> internally?</p>



<a name="212670293"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212670293" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Thom Chiovoloni <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212670293">(Oct 08 2020 at 10:20)</a>:</h4>
<p>wow that's huge. i have to try and think of what all the cases where i wanted this but couldn't have it were... </p>
<p>hmm... will memory-sanitizer still consider frozen uninit to be a problem? (or at least, if it did is that a bug?)</p>



<a name="212724789"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212724789" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212724789">(Oct 08 2020 at 17:38)</a>:</h4>
<p>I don't know about msan, but it probably depends where you're using it.  Reading/writing a frozen uninit address is still a problem.</p>
<p>(I think we still compile with LLVM 8, so we might not be able to require it yet, but experimenting with it should be ok, or using less-optimal versions on older LLVM -- like we could expose types that are normal floats on LLVM &lt;10 but are fast-math+freeze on LLVM &gt;= 10)</p>



<a name="212725954"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212725954" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> cuviper <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212725954">(Oct 08 2020 at 17:48)</a>:</h4>
<p>relevant thread:<br>
<a href="https://lists.llvm.org/pipermail/llvm-dev/2020-September/145318.html">https://lists.llvm.org/pipermail/llvm-dev/2020-September/145318.html</a><br>
<a href="https://lists.llvm.org/pipermail/llvm-dev/2020-September/145331.html">https://lists.llvm.org/pipermail/llvm-dev/2020-September/145331.html</a></p>



<a name="212726120"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212726120" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> cuviper <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212726120">(Oct 08 2020 at 17:49)</a>:</h4>
<p>there was also a related round table at the dev-meeting:<br>
<a href="https://lists.llvm.org/pipermail/llvm-dev/2020-October/145612.html">https://lists.llvm.org/pipermail/llvm-dev/2020-October/145612.html</a><br>
<a href="https://lists.llvm.org/pipermail/llvm-dev/2020-October/145692.html">https://lists.llvm.org/pipermail/llvm-dev/2020-October/145692.html</a></p>



<a name="212728570"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212728570" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212728570">(Oct 08 2020 at 18:07)</a>:</h4>
<p>Ah, interesting:</p>
<blockquote>
<p>Reading an indeterminate value from an lvalue that does not have char or std::byte type is UB [1].</p>
</blockquote>
<p>which pushes me towards "<code>fadd_fast</code> should take and return <code>MaybeUninit&lt;fN&gt;</code>"...</p>



<a name="212733801"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212733801" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212733801">(Oct 08 2020 at 18:50)</a>:</h4>
<p>Curiosity: do LLVM optimizers do a good job of "moving the freeze later"?  I'm imaging <code>freeze(fadd_fast( freeze(fadd_fast(a, b)), c))</code> -&gt; freeze(fadd_fast(fadd_fast(a, b), c))`.</p>
<p>I guess across loops that might be awkward, though, so it'd be better to have the freeze intrinsic separate from the <code>fadd_fast</code> one...</p>



<a name="212758391"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212758391" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mario Carneiro <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212758391">(Oct 08 2020 at 22:46)</a>:</h4>
<p>I recall there being discussion of implementing <code>std::mem::uninitialized()</code> (but not <code>MaybeUninit</code>) using <code>freeze</code></p>



<a name="212769804"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212769804" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Thom Chiovoloni <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212769804">(Oct 09 2020 at 01:44)</a>:</h4>
<p>there are still things i can use it for, but in the past i had hoped it could let me reduce the Pod requirement to a Copy and also let me use wider atomic ops for something like <a href="http://shift.click/rust/code/tearcell">http://shift.click/rust/code/tearcell</a> (which is more useful than i act in that post, although I've been meaning to write a followup explaining when you might want something like that and how you can use it without risking data corruption and such...)</p>
<p>But I don't think it helps there. If I have an <code>usize</code> that came from a load where some of the bytes were uninit.. the whole <code>usize</code> is <code>uninit</code>, and freeze isn't going to give me what i want (in practice it probably would, but yea)</p>
<p>Still, <code>freeze</code> seems insanely useful for trying to provide a safe API that works with any kind of uninitialized data, works with dodgy FFI code. Hell, I could imagine <code>freeze</code>ing something I believe to be initialized if the initialization code is at all likely to have bugs. (I'm assuming freeze is free since its a compiler-only concept)</p>
<p>The other thing that comes to mind is: I wonder if float casting would have been solved differently if this landed earlier... Even if not, could we use it to make <code>{f32,f64}::to_int_unchecked</code> safe? Or even have the checking be configurable globally the way overflow checks are...</p>



<a name="212770284"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212770284" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Joshua Nelson <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212770284">(Oct 09 2020 at 01:54)</a>:</h4>
<blockquote>
<p>(I'm assuming freeze is free since its a compiler-only concept)</p>
</blockquote>
<p>well <em>ackshually</em> <a href="https://internals.rust-lang.org/t/what-the-hardware-does-is-not-what-your-program-does-uninitialized-memory/10561/17?u=jyn514">https://internals.rust-lang.org/t/what-the-hardware-does-is-not-what-your-program-does-uninitialized-memory/10561/17?u=jyn514</a></p>



<a name="212770485"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212770485" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Thom Chiovoloni <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212770485">(Oct 09 2020 at 01:59)</a>:</h4>
<p>yeah i'm aware of that. does freeze actually handle that? it seems impossible without potentially writing to those pages which would be bad.</p>
<p>i also had assumed <code>freeze&lt;T&gt;(T) -&gt; T</code> which would avoid that issue, although it does mean it's hard to freeze data on the heap</p>



<a name="212780828"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212780828" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212780828">(Oct 09 2020 at 03:46)</a>:</h4>
<p><code>freeze</code> is opportunity cost -- from one of the emails linked earlier,</p>
<blockquote>
<p>To reduce the cost of fixing miscompilations using freeze instruction, we need to optimize freeze away whenever possible.</p>
</blockquote>
<p>Come to think of it, freeze codegen is always monomorphized, so the compiler knows the validity invariants.  I wonder if that means we could even make</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">impl</span><span class="o">&lt;</span><span class="n">T</span>: <span class="nc">Something</span><span class="o">&gt;</span><span class="w"> </span><span class="n">MaybeUninit</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="k">fn</span> <span class="nf">freeze</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-&gt; <span class="nc">T</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="o">..</span><span class="p">.</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>

<p>That'd mean adding a validity check, but making it safe is interesting.  (In addition to making some other unsafe one that doesn't do that.)</p>



<a name="212831802"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212831802" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Thom Chiovoloni <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212831802">(Oct 09 2020 at 14:20)</a>:</h4>
<p><code>MaybeUninit::&lt;String&gt;::uninit().freeze()</code> wcgw</p>



<a name="212853375"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212853375" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212853375">(Oct 09 2020 at 17:21)</a>:</h4>
<p>Good point.  Safe would have to meet safety invariants too, which it can't in general.  I guess there's three possibilities, then:</p>
<ul>
<li>A safe one bound on <code>safe_transmute::FromBytes</code> or whatever, for types with no safety nor validity invariants.  (Which is still useful for integers and types with padding and such.)</li>
<li>An unsafe pure-freeze one that's <code>MaybeUninit&lt;T&gt;</code> -&gt; <code>MaybeUninit&lt;T&gt;</code> because it doesn't enforce validity invariants</li>
<li>An unsafe one that enforces validity so can give <code>T</code> (if possible -- maybe the rules for reference validity might make this infeasible in practice.  Probably would at least need a "has no <code>&amp;muts</code> and all <code>&amp;</code>s are to <code>impl Freeze</code>" trait or something...)</li>
</ul>



<a name="212912977"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212912977" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212912977">(Oct 10 2020 at 12:04)</a>:</h4>
<p>also note that there are some major concerns for exposing <code>freeze</code> on the Rust level, see for example <a href="https://github.com/rust-lang/rfcs/pull/837">https://github.com/rust-lang/rfcs/pull/837</a></p>



<a name="212912990"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212912990" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212912990">(Oct 10 2020 at 12:05)</a>:</h4>
<p>with <code>MaybeUninit</code> around and a great proposal for handling uninit memory in <code>Read</code> on the table, what is even the remaining usecase for <code>freeze</code> in Rust?</p>



<a name="212932371"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212932371" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212932371">(Oct 10 2020 at 20:03)</a>:</h4>
<p><span class="user-mention" data-user-id="120791">@RalfJ</span> The specific case I was thinking about was removing the <code>poison</code> from fast-math ops so the result of them can be safely converted to <code>f32</code>.</p>



<a name="212955788"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212955788" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> RalfJ <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212955788">(Oct 11 2020 at 08:41)</a>:</h4>
<p>hm, interesting. wont that defeat many fast-math optimizations though? or did you want to do that only once at the end?</p>



<a name="212979135"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/212979135" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> scottmcm <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#212979135">(Oct 11 2020 at 19:55)</a>:</h4>
<p>"Once at the end" was my thought, yes.</p>
<p>Sketch:</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">struct</span> <span class="nc">FastF32</span><span class="p">(</span><span class="n">MaybeUninit</span><span class="o">&lt;</span><span class="kt">f32</span><span class="o">&gt;</span><span class="p">);</span><span class="w"></span>
<span class="k">impl</span><span class="w"> </span><span class="nb">From</span><span class="o">&lt;</span><span class="kt">f32</span><span class="o">&gt;</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">FastF32</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">FastF32</span><span class="p">(</span><span class="n">MaybeUninit</span>::<span class="n">new</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="c1">// obviously safe</span>
<span class="k">impl</span><span class="w"> </span><span class="nb">From</span><span class="o">&lt;</span><span class="n">FastF32</span><span class="o">&gt;</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="kt">f32</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">unsafe</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="p">.</span><span class="mf">0.</span><span class="n">freeze</span><span class="p">();</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="c1">// all f32 bit patterns are valid, per `f32::from_bits`, so freezing is sufficient for safety, though the results might be garbage</span>
<span class="k">impl</span><span class="w"> </span><span class="n">Add</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">FastF32</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">FastF32</span><span class="p">(</span><span class="n">new_fadd_fast_intrinsic</span><span class="p">(</span><span class="n">a</span><span class="p">.</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">.</span><span class="mi">0</span><span class="p">));</span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="c1">// inputs and outputs might be poison, but those are fine to have in a MaybeUninit</span>
</code></pre></div>

<p>(Hopefully with a less appealing name than "fast" to better convey what it does, though maybe we're stuck with it as a term of art now --backronym it to "Finite Allowing Sketchy Tranformations"?)</p>
<p>Hopefully LLVM would be able to remove "inner <code>freeze</code>s" if you have something like <code>freeze( fadd(a, freeze( fadd(b, c) )) )</code>, but probably better to not count on that.</p>



<a name="213050606"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/213050606" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jubilee <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#213050606">(Oct 12 2020 at 15:09)</a>:</h4>
<p>lol</p>



<a name="213052595"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking%20advantage%20of%20%60freeze%60%3F/near/213052595" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jubilee <a href="https://rust-lang.github.io/zulip_archive/stream/136281-t-lang/wg-unsafe-code-guidelines/topic/Taking.20advantage.20of.20.60freeze.60.3F.html#213052595">(Oct 12 2020 at 15:25)</a>:</h4>
<p>For some reason I want to call them flying-point numbers contra floating-point, but this might just be a taste for wuxia speaking. <a href="https://www.youtube.com/watch?v=2ObQm0XBmgI">https://www.youtube.com/watch?v=2ObQm0XBmgI</a></p>
<div class="youtube-video message_inline_image"><a data-id="2ObQm0XBmgI" href="https://www.youtube.com/watch?v=2ObQm0XBmgI"><img src="https://i.ytimg.com/vi/2ObQm0XBmgI/default.jpg"></a></div>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>